/**
 * 参数处理
 * @param {*} params  参数
 */
import Decimal from "decimal.js";
export function tansParams(params) {
  let result = ''
  for (const propName of Object.keys(params)) {
    const value = params[propName];
    var part = encodeURIComponent(propName) + "=";
    if (value !== null && value !== "" && typeof (value) !== "undefined") {
      if (typeof value === 'object') {
        for (const key of Object.keys(value)) {
          if (value[key] !== null && value[key] !== "" && typeof (value[key]) !== 'undefined') {
            let params = propName + '[' + key + ']';
            var subPart = encodeURIComponent(params) + "=";
            result += subPart + encodeURIComponent(value[key]) + "&";
          }
        }
      } else {
        result += part + encodeURIComponent(value) + "&";
      }
    }
  }
  return result
}
/**
 * @function 节流
 * @description 节流的意思是，规定时间内，只触发一次。
 * 比如我们设定500ms，在这个时间内，无论点击按钮多少次，它都只会触发一次。具体场景可以是抢购时候，
 * 由于有无数人 快速点击按钮，如果每次点击都发送请求，就会给服务器造成巨大的压力，但是我们进行节流
 * 后，就会大大减少请求的次数。
 * 比如防止表单提交按钮被多次触发，我们应该选择使用节流而不是防抖方案。
 * @param func {Function} 触发回调执行的函数
 * @param wait {Number} 时间间隔，单位ms
 * @param immediate {Boolean}  在开始还是结束处触发，比如设置wait为1000ms，如果在一秒内进行了5次操作，只触发一次，如果immediate为true，那么就会在第一次操作 触发回调，如果为false，就会在第5次操作触发回调。
 * @return null
 */
let timer; let flag
export function throttle(func, wait = 500, immediate = true) {
  if (immediate) {
    if (!flag) {
      flag = true
      // 如果是立即执行，则在wait毫秒内开始时执行
      typeof func === 'function' && func()
      timer = setTimeout(() => {
        flag = false
      }, wait)
    }
  } else if (!flag) {
    flag = true
    // 如果是非立即执行，则在wait毫秒内的结束处执行
    // eslint-disable-next-line no-unused-vars
    timer = setTimeout(() => {
      flag = false
      typeof func === 'function' && func()
    }, wait)
  }
}

/**
 * @function 防抖
 * @description 在连续的操作中，无论进行了多长时间，只有某一次的操作后在指定的时间内没有再操作，这一次才被判定有效。
 * 具体场景可以搜索框输入关键字过程中实时 请求服务器匹配搜索结果，如果不进行处理，
 * 那么就是输入框内容一直变化，导致一直发送请求。如果进行防抖处理，结果就是当我们
 * 输入内容完成后，一定时间(比如500ms)没有再 输入内容，这时再触发请求。
 * @param func {Function} 触发回调执行的函数
 * @param wait {Number} 时间间隔，单位ms
 * @param immediate {Boolean} 在开始还是结束处触发，如非特殊情况，一般默认为false即可
 * @return null
 */
let timeout = null
export function debounce(func, wait = 500, immediate = false) {
  // 清除定时器
  if (timeout !== null) clearTimeout(timeout)
  // 立即执行，此类情况一般用不到
  if (immediate) {
    const callNow = !timeout
    timeout = setTimeout(() => {
      timeout = null
    }, wait)
    if (callNow) typeof func === 'function' && func()
  } else {
    // 设置定时器，当最后一次操作后，timeout不会再被清除，所以在延时wait毫秒后执行func回调方法
    timeout = setTimeout(() => {
      typeof func === 'function' && func()
    }, wait)
  }
}
/**
 * 倒计时方法
 * @param {Date} startTime - 开始时间
 * @param {number} duration - 倒计时时长（分钟）
 * @param {function} callback - 回调函数，接收格式化后的时间字符串
 */
export function countDown(startTime, duration, callback) {
  // 将开始时间转换为时间戳
  const startTimestamp = startTime.getTime();
  // 计算结束时间的时间戳（30分钟后的时间）
  const endTimestamp = startTimestamp + duration * 60 * 1000;

  // 设置定时器，每秒更新一次
  const timer = setInterval(() => {
    // 获取当前时间
    const now = new Date().getTime();
    // 计算剩余时间
    const remainingTime = endTimestamp - now;

    // 如果倒计时结束
    if (remainingTime <= 0) {
      clearInterval(timer); // 清除定时器
      callback("00:00:00"); // 返回倒计时结束
      return;
    }

    // 格式化剩余时间为时分秒
    const hours = Math.floor(remainingTime / (1000 * 60 * 60));
    const minutes = Math.floor((remainingTime % (1000 * 60 * 60)) / (1000 * 60));
    const seconds = Math.floor((remainingTime % (1000 * 60)) / 1000);

    // 格式化时间为两位数
    const formatTime = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;

    // 调用回调函数，返回格式化后的时间
    callback(formatTime);
  }, 1000); // 每秒更新一次
}
/**
 * 倒计时方法
 * @param {Date} NumberOne - 开始时间
 * @param {number} NumberTwo - 倒计时时长（分钟）
 */



export function multiplication(NumberOne, NumberTwo) {
  const result = new Decimal(NumberOne).times(NumberTwo);
  console.log(result,'resultresult');
  
  return result
}


/**
 * 减
 */
export const _sub = (a, b) => {
  if (!`${a}` || !`${b}`) {
    return 0
  }
  return Decimal(a).sub(Decimal(b)).toNumber()
}






